home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 7 / BBS in a Box - Macintosh - Volume VII (BBS in a Box) (January 1993).iso / Files / Art / I / Imagic.cpt / External Functions / Grid Source / myFunction.c < prev    next >
Text File  |  1992-03-29  |  6KB  |  239 lines
  1. /**************************************************************************************************
  2.  *                    myFunctions.c
  3.  *
  4.  *            This is the file where you (the programmer) will put your code.  The three functions
  5.  *        below are the skeletal parts of what you must fill in.  Just enter your code into each
  6.  *        corresponding function, compile, and link with the ImagicXFunction Library.  Then, you
  7.  *        are done.
  8.  *
  9.  *        See Documentation for further help.  All of your answers should be answered there.
  10.  *
  11.  *        For more complex and technical questions that the documentation could not answer,
  12.  * contact me, Brian Powell:
  13.  *
  14.  *                (E-Mail is the best way.  Preferably Internet)
  15.  *                Internet :   powellb@boulder.colorado.edu
  16.  *                AppleLink:   d3706
  17.  *
  18.  *                (If you have no other means...)                
  19.  *                Brian Powell
  20.  *                Colorado Center for Astrodynamics Research
  21.  *                University of Colorado at Boulder
  22.  *                Campus Box 431
  23.  *                Boulder, CO        80309
  24.  *                (303) 492-6677
  25.  *************************************************************************************************/
  26.  
  27. #include "XFunctions.h"
  28. #include <math.h>
  29. #include <Dialogs.h>
  30.  
  31. /* Declare any functions you may create here.
  32.  */
  33. void AddGrid();
  34.  
  35. /* Definitions
  36.  */
  37. enum {
  38.     OK_BUTTON = 1,
  39.     CANCEL_BUTTON,
  40.     XSCALE,
  41.     YSCALE,
  42.     PIXEL,
  43.     DEGREE
  44. };
  45.  
  46. #define GRID_DIALOG 128
  47.  
  48. /* This is called whenever Imagic is beginning.  You set up your parameters here.  If there is
  49.  * anything you want to initialize, do that here.
  50.  */
  51. pascal OSErr Initialize(theParameters)
  52.     InitStruct *theParameters;
  53. {
  54.     OSErr theError = noErr;
  55.     
  56.     /* Insert Your Parameters Here.  If these parameters are fine with you, leave them, 
  57.      * otherwise set them up for your own needs.  This is also the default settings, so don't
  58.      * change it unless you need to. 
  59.      */
  60.      
  61.     theParameters->Filter = FALSE;
  62.     theParameters->NumOfImages = 1;
  63.     
  64.     /* Make sure that we are not goint to crash Imagic on startup with wrong calls. 
  65.      */
  66.     if (GetVersion() < EXTERNAL_FUNCTION_LIBRARY_VERSION_NUM) 
  67.         return (theError);
  68.         
  69.     /* Insert your initialization code here. 
  70.      */
  71.  
  72.     /* Let's go back to Imagic, giving it the parameters for our external module. */
  73.     return (theError);
  74. }
  75.  
  76. /* This function is called whenever the user selects your command from the menu.  This is the
  77.  * heart of your function.
  78.  */
  79. pascal OSErr ExecuteMenu()
  80. {
  81.     OSErr    theError=noErr;
  82.     DialogPtr    theDialog;        /* Dialog for asking the user how to space the grid. */
  83.     int            item;            /* Item selected by the user. */
  84.     ControlHandle    pixelHandle, degreeHandle, xHandle, yHandle; /* Controls. */
  85.     int            type;
  86.     Rect        box;
  87.     long            xscale, yscale;    /* Values of the grid spacing. */
  88.     GrafPtr        oldPort;        /* Store the old Graf Port. */
  89.     Boolean        pixelMode = TRUE;    /* Default to use units of pixels. */
  90.     char        string[256];        /* String to hold the values. */
  91.  
  92.     /* Load the dialog, if there's an error, give it back to Imagic.
  93.      */
  94.     theDialog = GetNewDialog(GRID_DIALOG, NIL, (WindowPtr)-1L);
  95.     if (theError = ResError()) return (theError);
  96.  
  97.     GetPort(&oldPort);
  98.     SetPort(theDialog);
  99.     
  100.     /* Get the dialog items.
  101.      */
  102.     GetDItem(theDialog, XSCALE, &type, &xHandle, &box);
  103.     GetDItem(theDialog, YSCALE, &type, &yHandle, &box);
  104.     GetDItem(theDialog, PIXEL, &type, &pixelHandle, &box);
  105.     GetDItem(theDialog, DEGREE, &type, °reeHandle, &box);
  106.  
  107.     /* Set the radio button, and select the text.
  108.      */
  109.     SelIText(theDialog, XSCALE, 0, 32767);
  110.     SetCtlValue(pixelHandle, TRUE);
  111.     SetCtlValue(degreeHandle, FALSE);
  112.     
  113.     /* Loop through getting the Dialog events.
  114.      */
  115.     while (TRUE) {
  116.     
  117.         /* Highlight the ok button.
  118.          */
  119.         OutlineButton(theDialog, OK_BUTTON);
  120.         ModalDialog(TextFilter, &item);
  121.         switch (item) {
  122.             case OK_BUTTON:
  123.                 GetIText(xHandle, (StringPtr)string);
  124.                 StringToNum((StringPtr)string, &xscale);
  125.                 GetIText(yHandle, (StringPtr)string);
  126.                 StringToNum((StringPtr)string, &yscale);
  127.                 DisposDialog(theDialog);
  128.                 SetPort(oldPort);
  129.                 AddGrid((int)xscale, (int)yscale, pixelMode);
  130.                 return (theError);
  131.                 break;
  132.             case CANCEL_BUTTON:
  133.                 DisposDialog(theDialog);
  134.                 SetPort(oldPort);
  135.                 return (theError);
  136.                 break;
  137.             case PIXEL:
  138.                 pixelMode = TRUE;
  139.                 SetCtlValue(pixelHandle, TRUE);
  140.                 SetCtlValue(degreeHandle, FALSE);
  141.                 break;
  142.             case DEGREE:
  143.                 pixelMode = FALSE;
  144.                 SetCtlValue(pixelHandle, FALSE);
  145.                 SetCtlValue(degreeHandle, TRUE);
  146.                 break;
  147.             default:
  148.                 break;
  149.         }
  150.     }
  151.     
  152.     /* Bye
  153.      */
  154.     return (theError);
  155. }
  156.  
  157. /* This function is called whenever Imagic quits.  If you need to clear anything up 
  158.  * before it quits, do so here.
  159.  */
  160. pascal OSErr Exit()
  161. {
  162.     OSErr theError = noErr;
  163.     
  164.     /* Insert your shut-down code here.  Deallocate anything you may have left around, Do
  165.      * anything you may need to do as Imagic is quitting. 
  166.      */
  167.  
  168.     /* Let's let Imagic quit, returning an error that may have occured.
  169.      */
  170.     return (theError);
  171. }
  172.  
  173. void AddGrid(x, y, pixelMode)
  174.     int    x, y;
  175.     Boolean pixelMode;
  176. {
  177.     ImageHandle    image;
  178.     double    thex, they;
  179.     int    i, newx, newy;
  180.     int    xsize, ysize;
  181.     Point topleft, botright;
  182.     short proj;
  183.     
  184.     /* Get the top image.  Make sure that we get one.
  185.      */
  186.     if ((image = GetTopImage())==NIL)
  187.         return;
  188.     
  189.     /* Okay, let's go through and draw it. We must make sure that we can work on it.
  190.      * Also, we'll set up for Undo, in case the user doesn't like it.
  191.      */
  192.     GetImageSize(image, &xsize, &ysize);
  193.     if (BeginImageWork(image, TRUE)) {
  194.     
  195.         /* If it's a straight pixel method, no problem.
  196.          */
  197.         if (pixelMode) {
  198.             /* Go through and do the vertical lines.
  199.              */
  200.             for (i=x; i<xsize; i+=x) {
  201.                 MoveTo(i,0);
  202.                 LineTo(i,ysize);
  203.             }
  204.             /* Now, do the horizontal lines.
  205.              */
  206.             for (i=y; i<ysize; i+=y) {
  207.                 MoveTo(0,i);
  208.                 LineTo(xsize, i);
  209.             }
  210.         }
  211.         
  212.         /* Otherwise, it is degree mode, which means we have to convert to pixels.
  213.          */
  214.         else {
  215.             GetImageGeography(image, &topleft, &botright, &proj);
  216.             thex=(double)(x+topleft.h);
  217.             they=(double)(y+topleft.v);
  218.             do {
  219.                 LatLonToPix(image, thex, they, &newx, &newy);
  220.                 MoveTo(newx, 0);
  221.                 LineTo(newx, ysize);
  222.                 thex+=(double)x;
  223.             } while (newx<xsize);
  224.             thex=(double)x;
  225.             they=(double)y;
  226.             do {
  227.                 LatLonToPix(image, thex, they, &newx, &newy);
  228.                 MoveTo(0, newy);
  229.                 LineTo(xsize, newy);
  230.                 they+=(double)y;
  231.             } while (newy<ysize);
  232.         }
  233.     }
  234.     
  235.     /* Finish up with the image.
  236.      */
  237.     EndImageWork(image);
  238. }
  239.